package com.cictec.middleware.core.entity;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;

@Table(name = "t_line_deviate_plan")
public class LineDeviatePlan implements Serializable {
	
	
	/** 开始站点序号 */
	@Transient
	private Integer startStationSequence;
	/** 截至站点序号 */
	@Transient
	private Integer endStationSequence;
	
	/** 开始站点序号 */
    public Integer getStartStationSequence() {
		return startStationSequence;
	}

    /** 开始站点序号 */
	public void setStartStationSequence(Integer startStationSequence) {
		this.startStationSequence = startStationSequence;
	}

	/** 截至站点序号 */
	public Integer getEndStationSequence() {
		return endStationSequence;
	}

	/** 截至站点序号 */
	public void setEndStationSequence(Integer endStationSequence) {
		this.endStationSequence = endStationSequence;
	}

	/**
     * 线路偏离计划表UUID
     */
    @Id
    @Column(name = "ldp_uuid")
    private String ldpUuid;

    /**
     * 线路UUID
     */
    @Column(name = "ldp_line_uuid")
    private String ldpLineUuid;

    /**
     * 线路上下行 1--上行 2---下行
     */
    @Column(name = "ldp_line_type")
    private String ldpLineType;

    /**
     * 计划开始时间
     */
    @Column(name = "ldp_start_time")
    private Date ldpStartTime;

    /**
     * 偏线计划结束时间
     */
    @Column(name = "ldp_end_time")
    private Date ldpEndTime;

    /**
     * 删除标记 1-删除 0 -- 未删除
     */
    @Column(name = "ldp_delete")
    private String ldpDelete;

    /**
     * 离线计划的状态 1--启用 2--停用
     */
    @Column(name = "ldp_status")
    private String ldpStatus;

    /**
     * 起始站UUID，对t_line_station的外键
     */
    @Column(name = "ldp_start_station_uuid")
    private String ldpStartStationUuid;

    /**
     * 结束站UUID，对t_line_station的外键
     */
    @Column(name = "ldp_end_station_uuid")
    private String ldpEndStationUuid;

    /**
     * 创建该计划的调度员UUID
     */
    @Column(name = "ldp_creator_uuid")
    private String ldpCreatorUuid;

    /**
     * 创建时间
     */
    @Column(name = "ldp_create_time")
    private Date ldpCreateTime;

    /**
     * 最后更新时间
     */
    @Column(name = "ldp_last_update_time")
    private Date ldpLastUpdateTime;

    private static final long serialVersionUID = 1L;

    /**
     * 获取线路偏离计划表UUID
     *
     * @return ldp_uuid - 线路偏离计划表UUID
     */
    public String getLdpUuid() {
        return ldpUuid;
    }

    /**
     * 设置线路偏离计划表UUID
     *
     * @param ldpUuid 线路偏离计划表UUID
     */
    public void setLdpUuid(String ldpUuid) {
        this.ldpUuid = ldpUuid == null ? null : ldpUuid.trim();
    }

    /**
     * 获取线路UUID
     *
     * @return ldp_line_uuid - 线路UUID
     */
    public String getLdpLineUuid() {
        return ldpLineUuid;
    }

    /**
     * 设置线路UUID
     *
     * @param ldpLineUuid 线路UUID
     */
    public void setLdpLineUuid(String ldpLineUuid) {
        this.ldpLineUuid = ldpLineUuid == null ? null : ldpLineUuid.trim();
    }

    /**
     * 获取线路上下行 1--上行 2---下行
     *
     * @return ldp_line_type - 线路上下行 1--上行 2---下行
     */
    public String getLdpLineType() {
        return ldpLineType;
    }

    /**
     * 设置线路上下行 1--上行 2---下行
     *
     * @param ldpLineType 线路上下行 1--上行 2---下行
     */
    public void setLdpLineType(String ldpLineType) {
        this.ldpLineType = ldpLineType == null ? null : ldpLineType.trim();
    }

    /**
     * 获取计划开始时间
     *
     * @return ldp_start_time - 计划开始时间
     */
    public Date getLdpStartTime() {
        return ldpStartTime;
    }

    /**
     * 设置计划开始时间
     *
     * @param ldpStartTime 计划开始时间
     */
    public void setLdpStartTime(Date ldpStartTime) {
        this.ldpStartTime = ldpStartTime;
    }

    /**
     * 获取偏线计划结束时间
     *
     * @return ldp_end_time - 偏线计划结束时间
     */
    public Date getLdpEndTime() {
        return ldpEndTime;
    }

    /**
     * 设置偏线计划结束时间
     *
     * @param ldpEndTime 偏线计划结束时间
     */
    public void setLdpEndTime(Date ldpEndTime) {
        this.ldpEndTime = ldpEndTime;
    }

    /**
     * 获取删除标记 1-删除 0 -- 未删除
     *
     * @return ldp_delete - 删除标记 1-删除 0 -- 未删除
     */
    public String getLdpDelete() {
        return ldpDelete;
    }

    /**
     * 设置删除标记 1-删除 0 -- 未删除
     *
     * @param ldpDelete 删除标记 1-删除 0 -- 未删除
     */
    public void setLdpDelete(String ldpDelete) {
        this.ldpDelete = ldpDelete == null ? null : ldpDelete.trim();
    }

    /**
     * 获取离线计划的状态 1--启用 2--停用
     *
     * @return ldp_status - 离线计划的状态 1--启用 2--停用
     */
    public String getLdpStatus() {
        return ldpStatus;
    }

    /**
     * 设置离线计划的状态 1--启用 2--停用
     *
     * @param ldpStatus 离线计划的状态 1--启用 2--停用
     */
    public void setLdpStatus(String ldpStatus) {
        this.ldpStatus = ldpStatus == null ? null : ldpStatus.trim();
    }

    /**
     * 获取起始站UUID，对t_line_station的外键
     *
     * @return ldp_start_station_uuid - 起始站UUID，对t_line_station的外键
     */
    public String getLdpStartStationUuid() {
        return ldpStartStationUuid;
    }

    /**
     * 设置起始站UUID，对t_line_station的外键
     *
     * @param ldpStartStationUuid 起始站UUID，对t_line_station的外键
     */
    public void setLdpStartStationUuid(String ldpStartStationUuid) {
        this.ldpStartStationUuid = ldpStartStationUuid == null ? null : ldpStartStationUuid.trim();
    }

    /**
     * 获取结束站UUID，对t_line_station的外键
     *
     * @return ldp_end_station_uuid - 结束站UUID，对t_line_station的外键
     */
    public String getLdpEndStationUuid() {
        return ldpEndStationUuid;
    }

    /**
     * 设置结束站UUID，对t_line_station的外键
     *
     * @param ldpEndStationUuid 结束站UUID，对t_line_station的外键
     */
    public void setLdpEndStationUuid(String ldpEndStationUuid) {
        this.ldpEndStationUuid = ldpEndStationUuid == null ? null : ldpEndStationUuid.trim();
    }

    /**
     * 获取创建该计划的调度员UUID
     *
     * @return ldp_creator_uuid - 创建该计划的调度员UUID
     */
    public String getLdpCreatorUuid() {
        return ldpCreatorUuid;
    }

    /**
     * 设置创建该计划的调度员UUID
     *
     * @param ldpCreatorUuid 创建该计划的调度员UUID
     */
    public void setLdpCreatorUuid(String ldpCreatorUuid) {
        this.ldpCreatorUuid = ldpCreatorUuid == null ? null : ldpCreatorUuid.trim();
    }

    /**
     * 获取创建时间
     *
     * @return ldp_create_time - 创建时间
     */
    public Date getLdpCreateTime() {
        return ldpCreateTime;
    }

    /**
     * 设置创建时间
     *
     * @param ldpCreateTime 创建时间
     */
    public void setLdpCreateTime(Date ldpCreateTime) {
        this.ldpCreateTime = ldpCreateTime;
    }

    /**
     * 获取最后更新时间
     *
     * @return ldp_last_update_time - 最后更新时间
     */
    public Date getLdpLastUpdateTime() {
        return ldpLastUpdateTime;
    }

    /**
     * 设置最后更新时间
     *
     * @param ldpLastUpdateTime 最后更新时间
     */
    public void setLdpLastUpdateTime(Date ldpLastUpdateTime) {
        this.ldpLastUpdateTime = ldpLastUpdateTime;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(getClass().getSimpleName());
        sb.append(" [");
        sb.append("Hash = ").append(hashCode());
        sb.append(", ldpUuid=").append(ldpUuid);
        sb.append(", ldpLineUuid=").append(ldpLineUuid);
        sb.append(", ldpLineType=").append(ldpLineType);
        sb.append(", ldpStartTime=").append(ldpStartTime);
        sb.append(", ldpEndTime=").append(ldpEndTime);
        sb.append(", ldpDelete=").append(ldpDelete);
        sb.append(", ldpStatus=").append(ldpStatus);
        sb.append(", ldpStartStationUuid=").append(ldpStartStationUuid);
        sb.append(", ldpEndStationUuid=").append(ldpEndStationUuid);
        sb.append(", ldpCreatorUuid=").append(ldpCreatorUuid);
        sb.append(", ldpCreateTime=").append(ldpCreateTime);
        sb.append(", ldpLastUpdateTime=").append(ldpLastUpdateTime);
        sb.append("]");
        return sb.toString();
    }
}